Структурные элементы класса, методы взаимодействия объектов и организация наследования

Содержание лекции

• Компонентные характеристики в определении класса
• Доступ к переменным и методам
• Конструкторы и создание объектов класса
• Время жизни объекта и управление ресурсами (RAII)
• Перегрузка и переопределение методов
• Наследование классов
• Создание многоуровневой иерархии
• Динамическая диспетчеризация методов
• Абстрактные классы и интерфейсы

Компонентные характеристики класса

#include <string>
#include <ctime>

class NetworkDevice {
private:                    // Закрытые члены — детали реализации
    std::string macAddress;
    std::string ipAddress;
    bool isConnected;
    
protected:                  // Защищённые — доступны наследникам
    int signalStrength;
    
public:                     // Открытые — публичный интерфейс
    NetworkDevice();        // Конструктор по умолчанию
    NetworkDevice(const std::string& mac);  // Параметризованный
    
    void connect();
    void disconnect();
    bool checkStatus() const;  // const — не изменяет объект
};

Спецификаторы доступа

class ServerConnection {
private:
    // Доступны только внутри класса (и friend)
    std::string password;
    void encryptData(std::string& data);
    
protected:
    // Доступны внутри класса и его наследникам
    std::string serverAddress;
    int port;
    void logConnection();
    
public:
    // Доступны из любого места программы
    void connect(const std::string& addr, int p);
    void sendData(const std::string& data);
    void disconnect();
};

// friend — полный доступ к private/protected
class ConnectionTest {
    friend class TestRunner;  // TestRunner видит всё
};

Доступ к переменным и методам

class NetworkPacket {
private:
    int packetId;
    std::string data;
    std::time_t timestamp;
    
public:
    // Геттеры — const, возвращают по значению или const&
    int getPacketId() const { return packetId; }
    const std::string& getData() const { return data; }
    
    // Сеттер — валидирует входные данные
    void setData(const std::string& newData) {
        if (newData.empty()) return;           // Пустые данные не допускаются
        if (newData.length() > 1500) return;   // MTU limit
        data = newData;
        timestamp = std::time(nullptr);
    }
    
    bool isValid() const {
        return !data.empty() && packetId > 0;
    }
};

Инкапсуляция данных

class SecureConnection {
private:
    std::string encryptionKey;
    bool connectionEstablished;
    
    std::string generateKey() {
        return "key_" + std::to_string(std::time(nullptr));
    }
    
    bool validateCertificate() { return true; }
    
public:
    void establishConnection() {
        encryptionKey = generateKey();
        connectionEstablished = validateCertificate();
    }
    
    void sendSecureMessage(const std::string& message) {
        if (!connectionEstablished) return;  // Предусловие
        std::string encrypted = encrypt(message, encryptionKey);
        // Отправка зашифрованного сообщения
    }
    
    // Запрещаем копирование — соединение уникально
    SecureConnection(const SecureConnection&) = delete;
    SecureConnection& operator=(const SecureConnection&) = delete;
};

Конструкторы класса

class NetworkClient {
private:
    std::string serverIp;
    int port;
    bool autoReconnect;
    
public:
    // Конструктор по умолчанию
    NetworkClient() 
        : serverIp("127.0.0.1"), port(8080), autoReconnect(true) {}
    
    // Параметризованный конструктор
    NetworkClient(const std::string& ip, int p) 
        : serverIp(ip), port(p), autoReconnect(true) {}
    
    // Конструктор копирования — компилятор генерирует автоматически
    NetworkClient(const NetworkClient&) = default;
    
    // Конструктор перемещения (C++11)
    NetworkClient(NetworkClient&& other) noexcept
        : serverIp(std::move(other.serverIp))
        , port(other.port)
        , autoReconnect(other.autoReconnect) {
        other.port = 0;
        other.autoReconnect = false;
    }
};

Списки инициализации

#include <string>
#include <vector>
#include <iostream>

class ServerConfig {
private:
    const int maxConnections;     // const — только через список инициализации
    const int bufferSize;         // const — только через список инициализации
    std::string serverName;
    std::vector<std::string> allowedIPs;
    
public:
    // Порядок в списке инициализации должен совпадать с объявлением!
    ServerConfig(const std::string& name, int maxConn) 
        : maxConnections(maxConn),       // 1-е поле
          bufferSize(4096),              // 2-е поле
          serverName(name),              // 3-е поле
          allowedIPs({"127.0.0.1", "192.168.1.1"}) {  // 4-е поле
        std::cout << "Server " << serverName << " configured" << std::endl;
    }
    
    // Delegating constructor (C++11)
    ServerConfig() : ServerConfig("default", 100) {}
};

Деструктор класса

class NetworkResource {
private:
    std::vector<int> buffer;        // Автоматическое управление
    int socketDescriptor;
    
public:
    NetworkResource(int size) 
        : buffer(size), socketDescriptor(socket(AF_INET, SOCK_STREAM, 0)) {}
    
    ~NetworkResource() {
        if (socketDescriptor >= 0) {
            close(socketDescriptor);
        }
    }
    
    // Rule of Five: определяем все 5 специальных функций
    NetworkResource(const NetworkResource&) = delete;
    NetworkResource& operator=(const NetworkResource&) = delete;
    NetworkResource(NetworkResource&& other) noexcept
        : buffer(std::move(other.buffer))
        , socketDescriptor(other.socketDescriptor) {
        other.socketDescriptor = -1;  // Предотвращаем double-close
    }
    NetworkResource& operator=(NetworkResource&& other) noexcept {
        if (this != &other) {
            close(socketDescriptor);
            buffer = std::move(other.buffer);
            socketDescriptor = other.socketDescriptor;
            other.socketDescriptor = -1;
        }
        return *this;
    }
};

Правило Zero/Three/Five

// Rule of Zero — лучший вариант: класс НЕ управляет ресурсами напрямую
class NetworkConfig {
    std::string host;
    int port;
    bool useTLS;
public:
    NetworkConfig(const std::string& h, int p, bool tls = false)
        : host(h), port(p), useTLS(tls) {}
    // Компилятор автоматически генерирует корректные:
    // ~NetworkConfig(), copy/move ctor, copy/move assign
};

// Rule of Five — класс ВЛАДЕЕТ ресурсом
class SocketGuard {
    int fd_;
public:
    explicit SocketGuard(int fd) : fd_(fd) {}
    ~SocketGuard() { if (fd_ >= 0) close(fd_); }
    SocketGuard(const SocketGuard&) = delete;
    SocketGuard& operator=(const SocketGuard&) = delete;
    SocketGuard(SocketGuard&& o) noexcept : fd_(o.fd_) { o.fd_ = -1; }
    SocketGuard& operator=(SocketGuard&& o) noexcept {
        if (this != &o) { if (fd_ >= 0) close(fd_); fd_ = o.fd_; o.fd_ = -1; }
        return *this;
    }
};

Создание объектов класса

class NetworkService {
    std::string serviceName;
    int port;
public:
    NetworkService(const std::string& name, int p) : serviceName(name), port(p) {}
    void start() { /* ... */ }
};

int main() {
    // Стек — предпочтительно (автоматическое уничтожение)
    NetworkService httpService("HTTP", 80);
    httpService.start();
    
    // Куча через unique_ptr — когда размер/время жизни неизвестны
    auto ftpService = std::make_unique<NetworkService>("FTP", 21);
    ftpService->start();
    // delete не нужен — unique_ptr освободит автоматически
    
    // Массив/вектор объектов
    std::vector<NetworkService> services;
    services.emplace_back("SSH", 22);   // Конструирование на месте
    services.emplace_back("DNS", 53);   // Без лишних копирований
}

Время жизни объекта

class ConnectionManager {
    static int activeConnections;
    int connectionId;
public:
    ConnectionManager() : connectionId(++activeConnections) {
        std::cout << "Connection " << connectionId << " created\n";
    }
    ~ConnectionManager() {
        activeConnections--;
        std::cout << "Connection " << connectionId << " destroyed\n";
    }
    static int getActiveConnections() { return activeConnections; }
    
    // Запрещаем копирование — соединение уникально
    ConnectionManager(const ConnectionManager&) = delete;
    ConnectionManager& operator=(const ConnectionManager&) = delete;
};

int ConnectionManager::activeConnections = 0;

void createTemporaryConnection() {
    ConnectionManager temp;
    std::cout << "Active: " << ConnectionManager::getActiveConnections() << "\n";
} // temp автоматически уничтожается — RAII в действии

Перегрузка методов

class DataProcessor {
public:
    // Перегрузка по количеству параметров
    void processData(const std::string& data) {
        std::cout << "Single: " << data << std::endl;
    }
    void processData(const std::string& data1, const std::string& data2) {
        std::cout << "Pair: " << data1 << " and " << data2 << std::endl;
    }
    
    // Перегрузка по типам параметров
    void processData(int number) {
        std::cout << "Number: " << number << std::endl;
    }
    
    // Перегрузка по const — для const и non-const объектов
    std::string& data() { return cachedData_; }
    const std::string& data() const { return cachedData_; }
    
private:
    std::string cachedData_;
};

Перегрузка операторов

class NetworkAddress {
    std::string ip_;
    int port_;
public:
    NetworkAddress(const std::string& ip, int p) : ip_(ip), port_(p) {}
    
    bool operator==(const NetworkAddress& other) const {
        return ip_ == other.ip_ && port_ == other.port_;
    }
    bool operator!=(const NetworkAddress& other) const {
        return !(*this == other);  // Используем == для !=
    }
    bool operator<(const NetworkAddress& other) const {
        return ip_ < other.ip_ || (ip_ == other.ip_ && port_ < other.port_);
    }
    
    // operator<< для вывода — через friend (нужен доступ к private)
    friend std::ostream& operator<<(std::ostream& os, const NetworkAddress& a) {
        return os << a.ip_ << ":" << a.port_;
    }
};

Переопределение методов (Override)

class NetworkProtocol {
public:
    virtual void sendData(const std::string& data) {
        std::cout << "Basic: " << data << std::endl;
    }
    virtual std::string receiveData() { return "Basic data"; }
    virtual ~NetworkProtocol() = default;
};

class TCPProtocol : public NetworkProtocol {
public:
    // override — проверка на этапе компиляции
    void sendData(const std::string& data) override {
        std::cout << "TCP reliable: " << data << std::endl;
    }
    std::string receiveData() override {
        return "TCP stream data";
    }
};

class UDPProtocol final : public NetworkProtocol {
public:
    void sendData(const std::string& data) override final {
        std::cout << "UDP datagram: " << data << std::endl;
    }
    std::string receiveData() override { return "UDP packet"; }
};

Виртуальные методы

class Connection {
protected:
    std::string connectionType;
public:
    Connection() : connectionType("Basic") {}
    
    virtual void establish() {
        std::cout << "Establishing " << connectionType << " connection\n";
    }
    
    // Чисто виртуальный метод — класс становится абстрактным
    virtual void transmit(const std::string& data) = 0;
    
    virtual ~Connection() = default;  // Виртуальный деструктор!
};

class SecureConnection : public Connection {
public:
    SecureConnection() { connectionType = "Secure"; }
    
    void establish() override {
        Connection::establish();  // Вызов базовой реализации
        std::cout << "TLS handshake completed\n";
    }
    
    void transmit(const std::string& data) override {
        std::cout << "Encrypted: " << data << std::endl;
    }
};

Наследование классов

class Device {
protected:
    std::string deviceId;
    std::string manufacturer;
    bool isActive;
public:
    Device(const std::string& id, const std::string& maker) 
        : deviceId(id), manufacturer(maker), isActive(false) {}
    virtual ~Device() = default;
    void activate() { isActive = true; }
    bool getStatus() const { return isActive; }
};

class NetworkDevice : public Device {
protected:
    std::string ipAddress;
public:
    NetworkDevice(const std::string& id, const std::string& maker, 
                  const std::string& ip) 
        : Device(id, maker), ipAddress(ip) {}  // Вызов конструктора базы
    std::string getIpAddress() const { return ipAddress; }
};

class Router final : public NetworkDevice {
    int portCount;
    std::vector<std::string> routingTable;
public:
    Router(const std::string& id, const std::string& maker, 
           const std::string& ip, int ports) 
        : NetworkDevice(id, maker, ip), portCount(ports) {}
    void addRoute(const std::string& dest) { routingTable.push_back(dest); }
};

Типы наследования

class BaseNetworkService {
public:
    void publicMethod() {}
protected:
    void protectedMethod() {}
private:
    void privateMethod() {}
};

// public — «IS-A» (стандартное наследование)
class PublicService : public BaseNetworkService {
    // publicMethod → public
    // protectedMethod → protected
};

// protected — редко используется
class ProtectedService : protected BaseNetworkService {
    // publicMethod → protected
    // protectedMethod → protected
};

// private — «implemented-in-terms-of»
class PrivateService : private BaseNetworkService {
    // publicMethod → private
    // protectedMethod → private
};

Множественное наследование

class IConnectable {
public:
    virtual void connect() = 0;
    virtual void disconnect() = 0;
    virtual ~IConnectable() = default;
};

class IDataProcessor {
public:
    virtual void processData(const std::string& data) = 0;
    virtual ~IDataProcessor() = default;
};

// Реализация нескольких интерфейсов — безопасное множественное наследование
class SecureNetworkConnection : public IConnectable, public IDataProcessor {
    bool isConnected_ = false;
public:
    void connect() override { isConnected_ = true; }
    void disconnect() override { isConnected_ = false; }
    void processData(const std::string& data) override {
        if (isConnected_) { /* обработка */ }
    }
};

Проблема ромбовидного наследования

class NetworkComponent {
protected:
    std::string componentId;
public:
    NetworkComponent(const std::string& id) : componentId(id) {}
    virtual void initialize() = 0;
    virtual ~NetworkComponent() = default;
};

// virtual — гарантирует один экземпляр NetworkComponent
class Sender : virtual public NetworkComponent {
public:
    Sender(const std::string& id) : NetworkComponent(id) {}
    virtual void send(const std::string& data) = 0;
};

class Receiver : virtual public NetworkComponent {
public:
    Receiver(const std::string& id) : NetworkComponent(id) {}
    virtual std::string receive() = 0;
};

class Transceiver : public Sender, public Receiver {
public:
    Transceiver(const std::string& id) 
        : NetworkComponent(id), Sender(id), Receiver(id) {}
    // Теперь componentId — один экземпляр, без неоднозначности
};

Сокрытие методов

class BaseServer {
public:
    void start() { std::cout << "Base server started\n"; }
    void stop()  { std::cout << "Base server stopped\n"; }
    virtual void handleRequest(const std::string& req) {
        std::cout << "Base: " << req << std::endl;
    }
};

class WebServer : public BaseServer {
public:
    // Сокрытие (hiding) — НЕ переопределение! start() не virtual
    void start() { 
        BaseServer::start();  // Явный вызов базового метода
        std::cout << "On port 80\n"; 
    }
    
    // Переопределение виртуального метода
    void handleRequest(const std::string& req) override {
        std::cout << "HTTP: " << req << std::endl;
    }
};

int main() {
    WebServer ws;
    ws.start();           // WebServer::start()
    ws.stop();            // BaseServer::stop() — не скрыт
    ws.BaseServer::start();  // Явный вызов скрытого метода
}

Динамическая диспетчеризация

class NetworkHandler {
public:
    virtual void processPacket(const std::string& packet) {
        std::cout << "Basic processing\n";
    }
    virtual ~NetworkHandler() = default;
};

class TCPHandler : public NetworkHandler {
public:
    void processPacket(const std::string& packet) override {
        std::cout << "TCP: reliable delivery\n";
    }
};

// Полиморфизм через указатель на базовый класс
void handleTraffic(NetworkHandler& handler, const std::string& packet) {
    handler.processPacket(packet);  // Виртуальный вызов — runtime
}

int main() {
    TCPHandler tcp;
    UDPHandler udp;
    handleTraffic(tcp, "GET /");   // Вызов TCPHandler::processPacket
    handleTraffic(udp, "DATAGRAM"); // Вызов UDPHandler::processPacket
    // Нет new/delete — все объекты на стеке!
}

Абстрактные классы

class Protocol {
protected:
    std::string protocolName;
    int defaultPort;
public:
    Protocol(const std::string& name, int port) 
        : protocolName(name), defaultPort(port) {}
    
    virtual void establishConnection(const std::string& addr, int port) = 0;
    virtual void sendData(const std::string& data) = 0;
    virtual std::string receiveData() = 0;
    virtual void closeConnection() = 0;
    
    virtual ~Protocol() = default;
    
    // Обычный метод — общая логика для всех наследников
    std::string getProtocolName() const { return protocolName; }
};

class HTTPProtocol : public Protocol {
public:
    HTTPProtocol() : Protocol("HTTP", 80) {}
    void establishConnection(const std::string& addr, int port) override { /*...*/ }
    void sendData(const std::string& data) override { /*...*/ }
    std::string receiveData() override { return "HTTP/1.1 200 OK\r\n\r\n"; }
    void closeConnection() override { /*...*/ }
};

Интерфейсы в C++

class IEncryption {
public:
    virtual std::string encrypt(const std::string& plaintext) = 0;
    virtual std::string decrypt(const std::string& ciphertext) = 0;
    virtual ~IEncryption() = default;
};

class IAuthentication {
public:
    virtual bool authenticate(const std::string& user, const std::string& pass) = 0;
    virtual void logout() = 0;
    virtual ~IAuthentication() = default;
};

// Реализация нескольких интерфейсов
class SecureService final : public IEncryption, public IAuthentication {
    int logLevel_ = 0;
public:
    std::string encrypt(const std::string& p) override { return "enc_" + p; }
    std::string decrypt(const std::string& c) override { return c.substr(4); }
    bool authenticate(const std::string& u, const std::string& p) override {
        return u == "admin" && p == "secret";
    }
    void logout() override {}
};

Шаблонные классы

template <typename T>
class NetworkBuffer {
    std::vector<T> buffer_;
    size_t maxSize_;
public:
    explicit NetworkBuffer(size_t size) : maxSize_(size) {}
    
    bool add(const T& item) {
        if (buffer_.size() >= maxSize_) return false;
        buffer_.push_back(item);
        return true;
    }
    
    std::optional<T> get() {  // C++17 — безопаснее чем T()
        if (buffer_.empty()) return std::nullopt;
        T item = std::move(buffer_.front());
        buffer_.erase(buffer_.begin());
        return item;
    }
    
    size_t size() const { return buffer_.size(); }
    bool empty() const { return buffer_.empty(); }
};

NetworkBuffer<std::string> stringBuffer(10);
stringBuffer.add("Hello");
auto val = stringBuffer.get();  // std::optional<string>

Заключение

Основные концепции:

• Инкапсуляция — сокрытие данных и реализации через private/protected
• Наследование — повторное использование кода, отношение IS-A
• Полиморфизм — единый интерфейс, разное поведение через virtual
• Абстракция — выделение общих характеристик через абстрактные классы

Рекомендации:

1. Стремитесь к Rule of Zero — не управляйте ресурсами напрямую
2. Предпочитайте композицию наследованию, когда это возможно
3. Всегда используйте override и virtual деструктор
4. Используйте = delete для запрета нежелательных операций
5. Множественное наследование — только от интерфейсов
6. Управляйте временем жизни через RAII и умные указатели

Вопросы для самопроверки

1. Чем отличаются спецификаторы доступа private, protected и public?
2. Какие типы конструкторов существуют в C++?
3. Что такое Rule of Zero/Three/Five?
4. В чём различие между перегрузкой и переопределением методов?
5. Зачем нужен override и что произойдёт без него?
6. Как решается проблема ромбовидного наследования?
7. Что такое чисто виртуальные методы и абстрактные классы?
8. Как работает динамическая диспетчеризация (vtable)?